1. Field of the Invention
The present invention relates, in general, to the generation, storage, and use of localized values and data by a software application, and, more particularly, to a computer system including administrative interfaces linked to applications operating in a computer network with the interfaces controlling generation of and access to localized application values and/or data stored in a centralized data store and, at least partially, in local memory.
2. Relevant Background
Applications are software programs that are used extensively in computers and computer networks to carry out a wide variety of useful tasks. Word processors, graphics programs, communications packages, spreadsheets, and database managers are well-known applications. To operate effectively, many applications utilize environmental variables or properties and other data or values that are localized to allow the application to have improved usefulness to a particular user. For example, if an application is used internationally, the application must be able to display text in a language useful to the user. An application may use localized properties and values to display information and function based on the geographic location of the user, based on the language preference of the user, or based on other user-specified or location-specific criteria.
Existing applications typically are configured to retrieve localized data from local system memory that is stored in either static files or databases for more dynamic values. A number of operating problems are associated with the present method of managing localized variables. Generally, an application will utilize an interface or program to handle accessing localized values in static files. For example, in Java™ systems, Resource Bundles are utilized by an application to access static property files, but the application is responsible for linking property files to a ResourceBundle. Other programming language environments use similar techniques that require the application to be aware of the location and/or identification of localization information and the localization options utilized for such values.
Further, inheritance of localized variables from one application to another application is typically not supported or difficult to implement by the programmer of the application. Instead of using inheritance, the localized values files will contain complete sets of needed values and as a result, contain many duplicate values or even conflicting values. Even if inheritance of localized values is provided between applications, presently each of the separate localized values static files is modified making inheritance inefficient and difficult to see its effects.
Existing methods of controlling access to and generation of localized application values often require the application to be shutdown and restarted to be able to make use of updated or new values. The changes to localized values tend to be all or nothing with all values required for an application being updated as a set, such as at the release of a new software package or the release of given database state. It is difficult to update one or selected sets of application values in existing systems. For example, for databases to support more flexible releases, additional attributes for each value need to be provided to reflect the value's state and this complicates select statements used to retrieve values. Further, localized values are typically limited to simple data structures, such as text strings and properties, because these are considered a low common denominator, but when more complex structures are desired, these data structures must be combined.
When a relational database management system (RDBMS) is associated with each application in a network, more dynamic localized data can be utilized but the data tends to be either a one dimensional (such as language only) or a flat, two dimensional (such as geographic specific and language) structure and fails to account for or allow inheritance, which would require complex select statements from the application. Additionally, applications that utilize a RDBMS are slow as a select statement must be issued to obtain each localized value, which results in numerous selects being issued. Alternatively, the RDBMS is used to feed values to static files that the application then accesses more directly. This alternative embodiment can still result in considerable delay.
Hence, there remains a need for an improved method and system for efficiently controlling generation of and access to localized application values, and preferably, such an improved method and system would be readily implemented within a distributed computer network in which numerous applications are operated on geographically diverse computer systems and would enable localized values to be easily updated by users rather than only highly trained information technology personnel and programmers.